package com.lz.virtualthread.common.utils;

import cn.hutool.extra.ftp.FtpException;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.*;
import java.net.SocketException;


public class FTPClientTemplate {

    protected static final Logger logger = LoggerFactory.getLogger(FTPClientTemplate.class);

    private String         host;
    private int            port;
    private String         username;
    private String         password;

    private boolean        binaryTransfer = true;
    private boolean        passiveMode    = true;
    //这里需要与服务器的编码一致，否则会出现乱码的情况
    private String         encoding       = "GBK";
    private int            clientTimeout  = 3000;
    //流缓冲区大小，影响下载和上传速度等
    private int bufferSize = 30*1024*1024;

    private boolean flag=true;

    public FTPClientTemplate(){};

    public FTPClientTemplate(FtpProperties ftpProperties){
        host = ftpProperties.getIp();
        port = ftpProperties.getPort();
        username = ftpProperties.getUserName();
        password = ftpProperties.getPassword();
    }

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public boolean isBinaryTransfer() {
        return binaryTransfer;
    }

    public void setBinaryTransfer(boolean binaryTransfer) {
        this.binaryTransfer = binaryTransfer;
    }

    public boolean isPassiveMode() {
        return passiveMode;
    }

    public void setPassiveMode(boolean passiveMode) {
        this.passiveMode = passiveMode;
    }

    public String getEncoding() {
        return encoding;
    }

    public void setEncoding(String encoding) {
        this.encoding = encoding;
    }

    public int getClientTimeout() {
        return clientTimeout;
    }

    public void setClientTimeout(int clientTimeout) {
        this.clientTimeout = clientTimeout;
    }

    //---------------------------------------------------------------------   
    // private method   
    //---------------------------------------------------------------------   
    /**
     * 返回一个FTPClient实例  
     *
     * @throws
     */
    private FTPClient getFTPClient() throws FtpException {
        FTPClient ftpClient = new FTPClient(); //构造一个FtpClient实例   
        ftpClient.setControlEncoding(encoding); //设置字符集
        ftpClient.setBufferSize(bufferSize);

        connect(ftpClient); //连接到ftp服务器
        logger.info("ftp连接成功");
        //设置为passive模式   
        if (passiveMode) {
            ftpClient.enterLocalPassiveMode();
        }
        setFileType(ftpClient); //设置文件传输类型

        try {
            ftpClient.setSoTimeout(clientTimeout);
        } catch (SocketException e) {
            throw new FtpException("Set timeout error.", e);
        }

        return ftpClient;
    }

    /**
     * 设置文件传输类型  
     *
     * @throws FtpException
     * @throws IOException
     */
    private void setFileType(FTPClient ftpClient) throws FtpException {
        try {
            if (binaryTransfer) {
                ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
            } else {
                ftpClient.setFileType(FTPClient.ASCII_FILE_TYPE);
            }
        } catch (IOException e) {
            throw new FtpException("Could not to set file type.", e);
        }
    }

    /**
     * 连接到ftp服务器  
     *
     * @param ftpClient
     * @return 连接成功返回true，否则返回false  
     * @throws FtpException
     */
    public boolean connect(FTPClient ftpClient) throws FtpException {
        try {
            ftpClient.connect(host, port);

            // 连接后检测返回码来校验连接是否成功   
            int reply = ftpClient.getReplyCode();

            if (FTPReply.isPositiveCompletion(reply)) {
                //登陆到ftp服务器   
                if (ftpClient.login(username, password)) {
                    setFileType(ftpClient);
                    logger.info("用户{}登录成功",username);
                    return true;
                }
            } else {
                ftpClient.disconnect();
                throw new FtpException("FTP server refused connection.");
            }
        } catch (IOException e) {
            if (ftpClient.isConnected()) {
                try {
                    ftpClient.disconnect(); //断开连接   
                } catch (IOException e1) {
                    throw new FtpException("Could not disconnect from server.", e);
                }

            }
            throw new FtpException("Could not connect to server.", e);
        }
        return false;
    }

    /**
     * 断开ftp连接  
     *
     * @throws FtpException
     */
    private void disconnect(FTPClient ftpClient) throws FtpException {
        try {
            ftpClient.logout();
            if (ftpClient.isConnected()) {
                ftpClient.disconnect();
            }
        } catch (IOException e) {
            throw new FtpException("Could not disconnect from server.", e);
        }
    }

    //---------------------------------------------------------------------   
    // public method   
    //---------------------------------------------------------------------   
    /**
     * 上传一个本地文件到远程指定文件  
     *
     * @param serverFile 服务器端文件名(包括完整路径)  
     * @param localFile 本地文件名(包括完整路径)  
     * @return 成功时，返回true，失败返回false  
     * @throws FtpException
     */
    public boolean put(String serverFile, String localFile) throws FtpException {
        return put(serverFile, localFile, false);
    }

    /**
     * 上传一个本地文件到远程指定文件  
     *
     * @param serverFile 服务器端文件名(包括完整路径)  
     * @param localFile 本地文件名(包括完整路径)  
     * @param delFile 成功后是否删除文件  
     * @return 成功时，返回true，失败返回false  
     * @throws FtpException
     */
    public boolean put(String serverFile, String localFile, boolean delFile) throws FtpException {
        FTPClient ftpClient = null;
        InputStream input = null;
        try {
            ftpClient = getFTPClient();
            // 处理传输   
            input = new FileInputStream(localFile);
            ftpClient.storeFile(serverFile, input);
            logger.debug("put " + localFile);
            input.close();
            if (delFile) {
                (new File(localFile)).delete();
            }
            logger.debug("delete " + localFile);
            return true;
        } catch (FileNotFoundException e) {
            throw new FtpException("local file not found.", e);
        } catch (IOException e) {
            throw new FtpException("Could not put file to server.", e);
        } finally {
            try {
                if (input != null) {
                    input.close();
                }
            } catch (Exception e) {
                throw new FtpException("Couldn't close FileInputStream.", e);
            }
            if (ftpClient != null) {
                disconnect(ftpClient); //断开连接   
            }
        }
    }

    /**
     * 下载一个远程文件到本地的指定文件  
     *
     * @param serverFile 服务器端文件名(包括完整路径)  
     * @param localFile 本地文件名(包括完整路径)  
     * @return 成功时，返回true，失败返回false  
     * @throws FtpException
     */
    public boolean get(String serverFile, String localFile) throws FtpException {
        return get(serverFile, localFile, false);
    }

    /**
     * 下载一个远程文件到本地的指定文件  
     *
     * @param serverFile 服务器端文件名(包括完整路径)  
     * @param localFile 本地文件名(包括完整路径)  
     * @return 成功时，返回true，失败返回false  
     * @throws FtpException
     */
    public boolean get(String serverFile, String localFile, boolean delFile) throws FtpException {
        OutputStream output = null;
        try {
            output = new FileOutputStream(localFile);
            return get(serverFile, output, delFile);
        } catch (FileNotFoundException e) {
            throw new FtpException("local file not found.", e);
        } finally {
            try {
                if (output != null) {
                    output.close();
                }
            } catch (IOException e) {
                throw new FtpException("Couldn't close FileOutputStream.", e);
            }
        }
    }

    /**
     * 下载一个远程文件到指定的流  
     * 处理完后记得关闭流  
     *
     * @param serverFile
     * @param output
     * @return
     * @throws FtpException
     */
    public boolean get(String serverFile, OutputStream output) throws FtpException {
        return get(serverFile, output, false);
    }

    /**
     * 下载一个远程文件到指定的流  
     * 处理完后记得关闭流  
     *
     * @param serverFile
     * @param output
     * @param delFile
     * @return
     * @throws FtpException
     */
    public boolean get(String serverFile, OutputStream output, boolean delFile) throws FtpException {
        FTPClient ftpClient = null;
        try {
            ftpClient = getFTPClient();
            // 处理传输   
            ftpClient.retrieveFile(serverFile, output);
            if (delFile) { // 删除远程文件   
                ftpClient.deleteFile(serverFile);
            }
            return true;
        } catch (IOException e) {
            throw new FtpException("Couldn't get file from server.", e);
        } finally {
            if (ftpClient != null) {
                disconnect(ftpClient); //断开连接   
            }
        }
    }



    /**
     * 从ftp服务器上删除一个文件  
     *
     * @param delFile
     * @return
     * @throws FtpException
     */
    public boolean delete(String delFile) throws FtpException {
        FTPClient ftpClient = null;
        try {
            ftpClient = getFTPClient();
            ftpClient.deleteFile(delFile);
            return true;
        } catch (IOException e) {
            throw new FtpException("Couldn't delete file from server.", e);
        } finally {
            if (ftpClient != null) {
                disconnect(ftpClient); //断开连接   
            }
        }
    }

    /**
     * 批量删除  
     *
     * @param delFiles
     * @return
     * @throws FtpException
     */
    public boolean delete(String[] delFiles) throws FtpException {
        FTPClient ftpClient = null;
        try {
            ftpClient = getFTPClient();
            for (String s : delFiles) {
                ftpClient.deleteFile(s);
            }
            return true;
        } catch (IOException e) {
            throw new FtpException("Couldn't delete file from server.", e);
        } finally {
            if (ftpClient != null) {
                disconnect(ftpClient); //断开连接   
            }
        }
    }

    /**
     * 列出远程默认目录下所有的文件  
     *
     * @return 远程默认目录下所有文件名的列表，目录不存在或者目录下没有文件时返回0长度的数组  
     * @throws FtpException
     */
    public String[] listNames() throws FtpException {
        return listNames(null);
    }

    /**
     * 列出远程目录下所有的文件  
     *
     * @param remotePath 远程目录名  
     * @return 远程目录下所有文件名的列表，目录不存在或者目录下没有文件时返回0长度的数组  
     * @throws FtpException
     */
    public String[] listNames(String remotePath) throws FtpException {
        FTPClient ftpClient = null;
        try {
            ftpClient = getFTPClient();
            String[] listNames = ftpClient.listNames(remotePath);
            return listNames;
        } catch (Exception e) {
            throw new FtpException("列出远程目录下所有的文件时出现异常", e);
        } finally {
            if (ftpClient != null) {
                disconnect(ftpClient); //断开连接   
            }
        }
    }


    /**
     * 列出远程默认目录下所有的文件
     *
     * @return 远程默认目录下所有文件名的列表，目录不存在或者目录下没有文件时返回0长度的数组
     * @throws FtpException
     */
    public FTPFile[] listFiles() throws FtpException {
        return listFiles(null);
    }

    /**
     * 列出远程目录下所有的文件
     *
     * @param remotePath 远程目录名
     * @return 远程目录下所有文件名的列表，目录不存在或者目录下没有文件时返回0长度的数组
     * @throws FtpException
     */
    public FTPFile[] listFiles(String remotePath) throws FtpException {
        FTPClient ftpClient = null;
        try {
            ftpClient = getFTPClient();
            FTPFile[] files = ftpClient.listFiles(remotePath);
            return files;
        } catch (IOException e) {
            throw new FtpException("列出远程目录下所有的文件时出现异常", e);
        } finally {
            if (ftpClient != null) {
                disconnect(ftpClient); //断开连接
            }
        }
    }



    public boolean isExist(String remoteFilePath)throws FtpException{

        FTPClient ftpClient = null;
        try{
            ftpClient = getFTPClient();
            File file=new File(remoteFilePath);

            String remotePath=remoteFilePath.substring(0,(remoteFilePath.indexOf(file.getName())-1));
            String[] listNames = ftpClient.listNames(remotePath);
            logger.info(remoteFilePath);
            for(int i=0;i<listNames.length;i++){

                if(remoteFilePath.equals(listNames[i])){
                    flag=true;
                    logger.info("文件:"+file.getName()+"已经存在了");
                    break;

                }else {
                    flag=false;
                }
            }

        } catch (IOException e) {
            throw new FtpException("查询文件是否存在文件时出现异常", e);
        } finally {
            if (ftpClient != null) {
                disconnect(ftpClient); //断开连接   
            }
        }
        return flag;
    }

}